home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / a_utils / expanded.lha / expanded / src / Typeout.C < prev   
C/C++ Source or Header  |  1992-03-19  |  5KB  |  239 lines
  1. //
  2. // Linear-Affine-Projective Geometry Package
  3. //
  4. // Typeout.C
  5. //
  6. // $Header$
  7. //
  8. // William J.R. Longabaugh 
  9. // University of Washington
  10. //
  11. // Implementation of the linear-affine-projective geometry
  12. // package described in William J.R. Longabaugh, "An Expanded
  13. // System for Coordinate-Free Geometric Programming", Master's 
  14. // thesis, University of Washington, 1992.
  15. //
  16. // Copyright (c) 1992, William J.R. Longabaugh
  17. //   Copying, use and development for non-commercial purposes permitted.
  18. //   All rights for commercial use reserved.
  19. //   This software is unsupported and without warranty; it is
  20. //   provided "as is".
  21. //
  22. // ***********************************************************************
  23.  
  24. #include <string.h>
  25. #include "Typeout.h"
  26.  
  27. // ***********************************************************************
  28. //
  29. // Implement stream output functions for the enumerated types.
  30. //
  31. // ***********************************************************************
  32.   
  33. ostream& SpaceTypeOut(ostream &c, SpaceType t)
  34. {
  35.   switch (t) {
  36.     case NULL_SPACE:
  37.       c << "Null space ";
  38.       break;
  39.     case VEC_SPACE:
  40.       c << "Vector space ";
  41.       break;
  42.     case AFF_SPACE:
  43.       c << "Affine space ";
  44.       break;
  45.     case PROJ_SPACE:
  46.       c << "Projective space ";
  47.       break;
  48.     case ANY_SPACE:
  49.       c << "Any space ";
  50.       break;
  51.     default:
  52.       c << "Unrecognized space type ";
  53.       break;
  54.   }
  55.   return (c);
  56. }
  57.  
  58. // ***********************************************************************
  59.   
  60. ostream& BasisTypeOut(ostream &c, BasisType t)
  61. {
  62.   switch (t) {
  63.     case NULL_BASIS:
  64.       c << "Null basis ";
  65.       break;
  66.     case SIMPLEX:
  67.       c << "Simplex ";
  68.       break;
  69.     case FRAME:
  70.       c << "Frame ";
  71.       break;
  72.     case VBASIS:
  73.       c << "Vector basis ";
  74.       break;
  75.     case HFRAME:
  76.       c << "Projective frame ";
  77.       break;
  78.     case ANY_BASIS:
  79.       c << "Any basis ";
  80.       break;
  81.     default:
  82.       c << "Unrecognized basis type ";
  83.       break;
  84.   }
  85.   return (c);
  86. }
  87.  
  88. // ***********************************************************************
  89.   
  90. ostream& GeObTypeOut(ostream &c, GeObType t)
  91. {
  92.   switch (t) {
  93.     case NULL_GEOB:
  94.       c << "Null geometric object ";
  95.       break;
  96.     case VECTOR:
  97.       c << "Vector ";
  98.       break;
  99.     case AFF_POINT:
  100.       c << "Affine point ";
  101.       break;
  102.     case AFF_VECTOR:
  103.       c << "Affine vector ";
  104.       break;
  105.     case VEC_EC:
  106.       c << "Vector equivalence class ";
  107.       break;
  108.     case AFF_VEC_EC:
  109.       c << "Affine vector equivalence class ";
  110.       break;
  111.     case PROJ_POINT:
  112.       c << "Projective point ";
  113.       break;
  114.     case ANY_GEOB:
  115.       c << "Any geometric object ";
  116.       break;
  117.     default:
  118.       c << "Unrecognized geometric object type ";
  119.       break;
  120.   }
  121.   return (c);
  122. }
  123.  
  124. // ***********************************************************************
  125.   
  126. ostream& MapTypeOut(ostream &c, MapType t)
  127. {
  128.   switch (t) {
  129.     case NULL_MAP:
  130.       c << "Null map ";
  131.       break;
  132.     case LIN_MAP:
  133.       c << "Linear map ";
  134.       break;
  135.     case AFF_MAP:
  136.       c << "Affine map ";
  137.       break;
  138.     case PROJ_MAP:
  139.       c << "Projective map ";
  140.       break;
  141.     case ANY_MAP:
  142.       c << "Any map ";
  143.       break;
  144.     default:
  145.       c << "Unrecognized map type ";
  146.       break;
  147.   }
  148.   return (c);
  149. }
  150.  
  151. // ***********************************************************************
  152.   
  153. ostream& MultiTypeOut(ostream &c, MultiType t)
  154. {
  155.   switch (t) {
  156.     case NULL_MULTI:
  157.       c << "Null multimap ";
  158.       break;
  159.     case MULTI_LINEAR:
  160.       c << "Multi-linear map ";
  161.       break;
  162.     case MULTI_AFFINE:
  163.       c << "Multi-affine map ";
  164.       break;
  165.     case ANY_MULTI:
  166.       c << "Any multimap ";
  167.       break;
  168.     default:
  169.       c << "Unrecognized multimap type ";
  170.       break;
  171.   }
  172.   return (c);
  173. }
  174.  
  175. // ***********************************************************************
  176.  
  177. ostream& SubSetTypeOut(ostream &c, SubSetType t)
  178. {
  179.   switch (t) {
  180.     case NULL_SUBSET:
  181.       c << "Null subset ";
  182.       break;
  183.     case LINEAR_SUBSET:
  184.       c << "Vector subset ";
  185.       break;
  186.     case AFFINE_SUBSET:
  187.       c << "Affine subset ";
  188.       break;
  189.     case PROJECTIVE_SUBSET:
  190.       c << "Projective subset ";
  191.       break;
  192.     case ANY_SUBSET:
  193.       c << "Any subset ";
  194.       break;
  195.     default:
  196.       c << "Unrecognized subset type ";
  197.       break;
  198.   }
  199.   return (c);
  200. }
  201. // ***********************************************************************
  202.  
  203. ostream& SRelOut(ostream &c, SRel t)
  204. {
  205.   switch (t) {
  206.     case LINEARIZATION:
  207.       c << "Linearization space ";
  208.       break;
  209.     case AFFINE:
  210.       c << "Affine space ";
  211.       break;
  212.     case TANGENT:
  213.       c << "Tangent vector space ";
  214.       break;
  215.     case PROJECT_COMP:
  216.       c << "Projective completion space ";
  217.       break;
  218.     case LIN_DUAL:
  219.       c << "Dual to linearization space ";
  220.       break;
  221.     case TANG_DUAL:
  222.       c << "Dual to tangent vector space ";
  223.       break;
  224.     case NO_RELATION:
  225.       c << "No relation ";
  226.       break;
  227.     case SAME_SPACE:
  228.       c << "Same space ";
  229.       break;
  230.     default:
  231.       c << "Unrecognized space relation ";
  232.       break;
  233.   }
  234.   return (c);
  235. }
  236.  
  237.  
  238.  
  239.